/**
 * 战斗模型
 * @param {Object} param0 - 包含 UserA 和 UserB 的战斗信息
 * @returns {Object} 战斗结果
 */
export async function monsterbattle({ UserA, UserB }) {
  const msg = []; // 战斗消息记录
  let round = 0; // 回合计数

  // 初始化双方状态
  const participants = {
    A: { ...UserA, isAlive: true },
    B: { ...UserB, isAlive: true }
  };

  // 确定出手顺序
  const first = participants.A.速度 >= participants.B.速度 ? 'A' : 'B';
  const second = first === 'A' ? 'B' : 'A';

  // 战斗循环
  while (participants.A.isAlive && participants.B.isAlive) {
    round++;
    msg.push(`\n第${round}回合开始！`);

    // 先手攻击
    await executeAttack(participants[first], participants[second], msg);

    // 检查后手是否死亡
    if (!participants[second].isAlive) {
      msg.push(`\n[${participants[first].名号}]击败了[${participants[second].名号}]！`);
      break;
    }

    // 后手攻击
    await executeAttack(participants[second], participants[first], msg);

    // 检查先手是否死亡
    if (!participants[first].isAlive) {
      msg.push(`\n[${participants[second].名号}]击败了[${participants[first].名号}]！`);
      break;
    }

    // 回合上限判断
    if (round >= 16) {
      msg.push(`\n[${participants.A.名号}]与[${participants.B.名号}]势均力敌，经过${round}回合仍未分出胜负！`);
      break;
    }
  }

  // 返回战斗结果
  return {
    当前血量: {
      a: participants.A.当前血量,
      b: participants.B.当前血量
    },
    victory: participants.A.isAlive
      ? participants.A.uid
      : participants.B.isAlive
      ? participants.B.uid
      : null, // 平手时返回 null
    processMsg: msg, // 战斗过程消息
    resultMsg: participants.A.isAlive
      ? `\n[${participants.A.名号}]击败了[${participants.B.名号}]！`
      : participants.B.isAlive
      ? `\n[${participants.B.名号}]击败了[${participants.A.名号}]！`
      : `\n[${participants.A.名号}]与[${participants.B.名号}]势均力敌，经过${round}回合仍未分出胜负！` // 平手消息
  };
}

/**
 * 执行攻击逻辑
 * @param {Object} attacker - 攻击方
 * @param {Object} defender - 防守方
 * @param {Array} msg - 战斗消息记录
 */
async function executeAttack(attacker, defender, msg) {
  const damage = calculateDamage(attacker, defender);

  // 暴击判定逻辑
  const critChance = Math.random();
  const isCrit = critChance < attacker.暴击率;

  const damageDealt = isCrit ? damage.critDamage : damage.baseDamage;

  defender.当前血量 -= damageDealt;
  if (defender.当前血量 <= 0) {
    defender.当前血量 = 0;
    defender.isAlive = false;
  }

  const attackType = isCrit ? '💥暴击伤害' : '普通伤害';
  msg.push(`\n[${attacker.名号}]对[${defender.名号}]造成 ${damageDealt} ${attackType}`);
}

/**
 * 计算伤害
 * @param {Object} attacker - 攻击方
 * @param {Object} defender - 防守方
 * @returns {Object} 包含基础伤害和暴击伤害
 */
function calculateDamage(attacker, defender) {
  // 动态最低伤害：基础值为 50，随攻击力提升
  const minDamage = Math.max(50, Math.floor(attacker.攻击 * 0.1));

  // 基础伤害：攻击减去防御，确保不低于动态最低伤害
  const baseDamage = Math.max(attacker.攻击 - defender.防御, minDamage);

  // 暴击伤害：基础伤害乘以暴击倍率
  const critDamage = Math.floor(baseDamage * (1 + attacker.暴击伤害 / 10));

  return { baseDamage, critDamage };
}

